Forth.Starting Forth

: for new definitions
word defined command
convention: separate name from contents by 3 spaces
- eg. : STAR 42 EMIT;
CR carriage return; EMIT emit ascii char; SPACES, SPACE tsia
0 DO ... LOOP
Compiling translates definitions to dictionary form
Execution
- INTERPRET scans input for characters separated by whitespaces
- words in dictionaries are sent to EXECUTE
- otherwise, sent to NUMBER, which stores in temporary location for numbers
- otherwise, error
ANS Forth allows for 31 characters of a name to be stored
." (dot-quote) for strings inside definitions
- add spaces after the quotes
numbers are stored on the stack
postfix allows using all numbers from the stack
Accessing the stack isn't scoped: words just work
. removes and prints numbers from the stack
Stack underflow on trying to pop too much
Glossary list of newly created words / meanings
Stack notation
- ( before – after )
- things that should be on the stack before,
- things that will be on the stack after
- eg. = + ( n1 n2 – sum ) =
- rightmost item is topmost on the stack
Words are fully compiled and don't retain references
+, -, *, /
Operators are integers; single length signed numbers
Can have no-op words as well eg : INCH ;
/MOD ( n1 n2 – rem quot )
MOD ( n1 n2 – rem )
SWAP switches top two stack items
DUP duplicates it, OVER copies second item to top
ROT rotates third item to top, DROP drops top item
.S non destructive stack print
2SWAP, 2DUP, 2OVER, 2DROP
- handles numbers in pairs / double length numbers
Text interpreter always starts at the back of the dictionary
FORGET removes most recent definition of word
MARKER <label> retains current system state
- using <label> returns to it, removing all words defined after
INCLUDE <filename> to grab a file
dictionary entries go to memory, source text is saved to disk
USE <filename> sets up a block
( ... ) act as comments, everything between () is ignored
LIST lists a disk block, LOAD loads a disk block
1 BLOCK copies block 1 of open file into system
Block division of disk memory with up to 1024 chars
Buffer temporary storage area
<CONDITION> IF <IF-TRUE> ELSE <IF-FALSE> THEN <ALWAYS EXECUTED>
- Generally define conditionals as ?CHECK
- gforth stack stores 0 for false, non zero for true
#+BEGIN_SRC

, <>, 0, 0>, 0<, <, > #+END_SRC
INVERT is the not used after conditionals
OR, AND
?DUP
- Duplicates non zero topmost values
ABORT"
- raise error and die
PAGE clear terminal screen
ABS absolute value, NEGATE, MIN, MAX
Parameter Stack – standard stack used by parameters
- arguments passed from word to word
Return Stack --
- used by forth to hold pointers
- can be used to temporarily hold values
  - must be cleared by the time we reach ;
>R moves value from parameter to return stack
R> moves value from return to parameter stack
R@ copies top item from return stack to parameter stack
Processors that support hardware floating point are faster than fixed point
Scaling operators help with fixed point
*/ ( n1 n2 n3 – n4 ) n1 * n2 / n3 with a double length intermediate result
*/MOD similar
Can approximate constants by pairs of integers with errors < 10^-8
Definite loop: <LIMIT> <INDEX> DO...LOOP
- index and limit are stored on the loop control stack
- I copies loop index onto stack; J next outer loop index
U.R unsigned number print, right justified
DO ... <INC> +LOOP uses a custom increment
- INC must be put on the loop each time around
Adding random words triggers ABORT, which also clears all stacks
Indefinite loop: BEGIN ... <flag> UNTIL
Infinite loop: BEGIN ... AGAIN
- Unconditionally branches back
BEGIN ... <f> WHILE ... REPEAT
- test happens in the middle
LEAVE causes loops to immediately end
QUIT removes ok at end of execution
NIP drop first item below stack
2* arithmetic left shift, 2/ arithmetic right shift
Stack holds unsigned or signed numbers
- you have to remember to handle appropriately
., prints stack value as signed number
U. prints it as unsigned
UM*, UM/MOD, U< – single length unsigned ops
HEX, OCTAL, DECIMAL change base
Prefix hexadecimals with a 0
= n BASE ! ;= Change base
Number followed by a . is converted to a double cell number
D. print double length number
<# #S #> TYPE ;
- <# bracket-number
- #> number-bracket
- #S "numbers"
  - converts value on stack into ascii
- TYPE prints out the characters
HOLD inserts character at current position
<# ... #> converts double length unsigned values to strings
<# ... ROT SIGN #> double length signed value etc. etc.
M+ double length + single length
SM/REM d1 / n1, returning n2 and n3
FM/MOD, M*, M*/
Defined numbers get compiled into the dictionary, depending on defined base
VARIABLE DATE, creating variables;
- 12 DATE ! ! == store
- DATE @ @ == fetch onto stack
- DATE ? = =DATE @ .
Variables are useful for values that need to be changed after the definition has been compiled
+! increment stored value
=<VALUE> CONSTANT <NAME> =
- constants for readability
2VARIABLE, 2CONSTANT, 2!, 2@
VARIABLE <name> <x> CELLS ALLOT
- adds additional cells to the variable
- <val> <name> <index> CELLS + <ops>
FILL (addr n char -- ) fills n bytes
ERASE (addr n -- ) zeroes out n bytes
addr count DUMP to print out arrays
Can also use byte arrays: C! ( char addr - ), C@ ( addr - )
CREATE name <value1> , <value2> , <value3> ... ,
- CREATE Puts a new name in the dictionary
- , takes a number from the stack and puts it into the array
- C, for creating byte arrays
' Identifies location in memory from dictionary, returns execution token
EXECUTE executes token on stack
DUMP shows raw contents
Vectored execution
- Execute indirectly by storing execution token (xt) in a variable
- allows changing the pointer later – like a lambda!
Label pointers with a ' prefix, eg. 'aloha
Tick always goes to the next word in the input stream, not the definition
['] goes to the next word in the definition
Dictionary entries
- name field, link field, code/code pointer field and data field
- name: first byte defines number of characters, then an ascii rep of the name
- precedence bit: if it should be executed during compilation or compiled into the definition
- link: address of previous definition, allows for searching dictionary
  - ' starts with the most recent word and walks backwards
- code pointer
  - address of instruction executed for this word
  - for variables, pushes address of variable onto stack
  - for constant, pushes contents onto stack
  - etc.
  - points to "run-time" code
  - can be actual machine code
- data field
  - length depends on type variable, constant, array, etc.
  - >BODY gets beginning of data field
  - contains execution tokens of words that comprise the definition
- execution token is code pointer
EXIT returns execution to next higher level definition, return from subroutine
return stack keeps return addresses
QUIT is the outermost loop, INTERPRET s and prints oks.
Memory map
- forth / system variables / load definitions / user dictionary (stack)
- pad stores ascii, etc. that are being manipulated
- parameter stack grows up
- TIB grows down / terminal input buffer – stores text from terminal
- return stack grows up
- user variables/buffers at the end
- CP points to the next cell in dictionary
- HERE puts CP on the stack, can be used to estimate size of stack
- SP provides address of top stack location
- S0 contains address of cell below the empty stack
- TIB, #TIB, BASE, H, >IN
- User variables
  - kept in an "user table"
  - each task can get a custom variable even if the definition is same
  - defined with USER
Vocabularies manage the dictionary
EMIT ASCII re on the stack and prints it
TYPE prints entire string given starting address in memory

Backlinks